/**
 * 在最初的设计中，获取版本号采用了同步+缓存变量的方式
 * 为防止阻塞原生的UI线程，现全改为异步方式，并兼容以前的同步使用方式
 * 建议使用：
 *      enableTeleConference(function(flag) {
 *          // 调用回调函数时，是否满足版本要求的bool值会自动传给回调函数。
 *      });
 * @param exports
 */
(function(exports) {
    "use strict";

    var URL_GET_VERSION = "/reqlocal?upversion=",
        APP_VERSION = null;   // 涨乐APP的版本号

    var version = {
        /**
         * 异步初始化，当该文件引入时，会立即初始化
         */
        init : function() {
            var that = this;
            $.ajax({
                url : URL_GET_VERSION,
                type : "get",
                success : function(data) {
                    var ver = data.UPVERSION;
                    if (!base.empty(ver)) {
                        that.APP_VERSION = ver;
                    }
                }
            });
        },

        /**
         * 获取版本号字符串。取版本号统一用这个函数来取。 不会重复去取
         */
        getAppVersion : function() {
            if (base.empty(this.APP_VERSION)) {
                base.log("init.");
                var that = this;
                $.ajax({
                    url : URL_GET_VERSION,
                    type : "get",
                    async : false,
                    success : function(data) {
                        that.APP_VERSION = data.UPVERSION;
                    }
                });
            }
            return this.APP_VERSION;
        },
    	
    	/**
         * 异步获取版本号字符串。
         * 不会重复去取
         */
        getAppVersionAsync : function(callback) {
            var that = this;
            if (base.empty( this.APP_VERSION )) {
                base.log("init.");
                $.ajax({
                    url: URL_GET_VERSION,
                    type: "get",
                    success: function(data) {
                        that.APP_VERSION = data.UPVERSION;
                        callback && callback(that.APP_VERSION);
                    }
                });
            } else {
                callback && callback(that.APP_VERSION);
            }
        },

                
        /**
         * 版本判断逻辑。是否支持编辑自选股：添加、删除
         * @param v 版本字符串
         * @return true - 支持； false - 不支持；
         */
        editSelfSelect : function(v) {
            if ((base.isAndroid() && this.compare(v, "3.0.5") >= 0) || (base.isIOS() && this.compare(v, "3.0.4") >= 0)) {
                return true;
            }
            return false;
        },

        /**
         * 版本判断逻辑。是否支持电话会议
         * @return true - 支持； false - 不支持；
         */
        teleConference : function(v) {
            if (this.compare(v, "3.0.2") >= 0) {
                return true;
            }
            return false;
        },

        /**
         * 版本判断逻辑。是否支持分享到指定SNS
         * @return true - 支持； false - 不支持；
         */
        specifySNS : function(v) {
            if ((base.isAndroid() && this.compare(v, "3.1.1") >= 0) || (base.isIOS() && this.compare(v, "3.1.0") >= 0)) {
                return true;
            }
            return false;
        },
        
        /**
         * 版本判断逻辑。是否支持用户反馈功能
         * @return true - 支持； false - 不支持；
         */
        feedback : function(v) {
            if (this.compare(v, "3.1.1") >= 0) {
                return true;
            }
            return false;
        },
        
        /**
         * 版本判断逻辑。是否支持股票讨论区功能 
         *不支持从网页跳到native的讨论区
         * @return true - 支持； false - 不支持；
         */
        forum : function(v) {
            if (this.compare(v, "3.1.0") >= 0) {
                return true;
            }
            return false;
        },
        
        /**
         * 版本判断逻辑。是否支持猜涨跌讨论区功能
         * 从3.2.2开始支持从网页跳到native的讨论区
         * @return true - 支持； false - 不支持；
         *
         */
        jumpForum : function(v) {
            if (this.compare(v, "3.2.2") >= 0) {
                return true;
            }
            return false;
        },

        /**
         * 是否支持电话会议
         * @param x 参数可以是空，可以是一个版本字符串，可以是一个回调函数
         */
        enableTeleConference : function(x) {
            if (x) {
                if (typeof x === "function") {
                    this.enableTeleConferenceAsync(x);
                } else {
                    return this.teleConference(x);
                }
            } else {
                var v = this.getAppVersion();
                return this.teleConference(v);
            }
        },

        enableTeleConferenceAsync : function(callback) {
            var that = this;
            this.getAppVersionAsync(function(ver) {
                callback && callback(that.teleConference(ver));
            });
        },

        /**
         * 是否支持编辑自选股：添加、删除
         * @param x  参数可以是空，可以是一个版本字符串，可以是一个回调函数
         */
        enableEditSelfSelect : function(x) {
            if (x) {
                if (typeof x === "function") {
                    this.enableEditSelfSelectAsync(x);
                } else {
                    return this.editSelfSelect(x);
                }
            } else {
                var v = this.getAppVersion();
                return this.editSelfSelect(v);
            }
        },

        enableEditSelfSelectAsync : function(callback) {
            var that = this;
            this.getAppVersionAsync(function(ver) {
                callback && callback(that.editSelfSelect(ver));
            });
        },

        /**
         * 是否支持分享到指定SNS平台
         * @param x 参数可以是空，可以是一个版本字符串，可以是一个回调函数
         */
        enableSpecifySNS : function(x) {
            if (x) {
                if (typeof x === "function") {
                    this.enableSpecifySNSAsync(x);
                } else {
                    return this.specifySNS(x);
                }
            } else {
                var v = this.getAppVersion();
                return this.specifySNS(v);
            }
        },

        enableSpecifySNSAsync : function(callback) {
            var that = this;
            this.getAppVersionAsync(function(ver) {
                callback && callback(that.specifySNS(ver));
            });
        },
        
        /**
         * 是否支持用户反馈功能
         * @param x 参数可以是空，可以是一个版本字符串，可以是一个回调函数
         */
        enableFeedback : function(x) {
            if (x) {
                if (typeof x === "function") {
                    this.enableFeedbackAsync(x);
                } else {
                    return this.feedback(x);
                }
            } else {
                var v = this.getAppVersion();
                return this.feedback(v);
            }
        },

        enableFeedbackAsync : function(callback) {
            var that = this;
            this.getAppVersionAsync(function(ver) {
                callback && callback(that.feedback(ver));
            });
        },
        
        /**
         * 是否支持股票讨论区
         * @param x 参数可以是空，可以是一个版本字符串，可以是一个回调函数
         */
        enableForum : function(x) {
            if (x) {
                if (typeof x === "function") {
                    this.enableForumAsync(x);
                } else {
                    return this.forum(x);
                }
            } else {
                var v = this.getAppVersion();
                return this.forum(v);
            }
        },

        enableForumAsync : function(callback) {
            var that = this;
            this.getAppVersionAsync(function(ver) {
                callback && callback(that.forum(ver));
            });
        },
        /*
        *是否支持猜涨跌讨论区
        *3.2.2版本以后支持网页跳转native讨论区
        */
        enableForumAsyncNew : function(callback) {
            var that = this;
            this.getAppVersionAsync(function(ver) {
                callback && callback(that.jumpForum(ver));
            });
        },

        /**
         * 基础函数，执行一次版本判断（暂不使用）
         * @param sync 同步执行的函数
         * @param async  异步执行的函数
         * @param logic 具体的版本判断逻辑
         * @param param 上述sync或asycn函数中带的参数
         */
        work : function(async, logic, param) {
            if (param) {
                if (typeof param === "function") {
                    async(param);
                } else {
                    return logic(param);
                }
            } else {
                var v = this.getAppVersion();
                return logic(v);
            }
        }, 

        /**
         * 版本转化为数值，主要用于版本比较
         */
    	value: function(version) {
    		return base.versionValue(version);
    	},

        /**
         * 版本比较
         */
    	compare: function(ver1, ver2) {
    		return base.versionCompare(ver1, ver2);
    	},

        /**
         *
         * 是否支持navigationbar=0
         * ios
         * 从 3.0.4 支持这个参数
         * 但 3.1.0 版本有一个改动，导致这个参数失效
         * 在 3.2.0 版本修复改为支持
         * android
         * 高于3.0.3 支持
         * 返回值为true代表支持
         *
         */
        navV : function(v){
            if(base.isIOS() && this.compare(v, '3.0.4') >= 0 && this.compare(v, '3.1.0') < 0 || base.isIOS() && this.compare(v, '3.2.0') >= 0 || base.isAndroid() && this.compare(v, '3.0.3') >= 0){
                return true;
            }
            return false;

        },
        /**
         * 是否支持navigationbar=0
         * @param x 参数可以是空，可以是一个版本字符串，可以是一个回调函数
         */
        enableHideNav : function(x){
            if (x){
                if(typeof x === 'function'){
                    this.enableHideNavAsync(x);
                }else{
                    return this.navV(x);
                }
            }else{
                var v = this.getAppVersion();
                return this.navV(v);
            }
        },
        enableHideNavAsync : function(callback){
            var that = this;
            this.getAppVersionAsync(function(ver){
                callback && callback(that.navV(ver));
            });
        },

        /**
         *
         * 是否支持涨乐FM
         * android  > 3.2.3
         * ios    >  3.2.4
         * 返回值为true代表支持
         *
         */
        fmV : function(v){
            if (this.compare(v, '3.2.5') >= 0){
                return true;
            }
            return false;
        },

        /**
         * 是否支持涨乐FM
         * @param x 参数可以是空，可以是一个版本字符串，可以是一个回调函数
         */
        enableShowFm : function(x){
            if (x){
                if(typeof x === 'function'){
                    this.enableShowFmAsync(x);
                }else{
                    return this.fmV(x);
                }
            }else{
                var v = this.getAppVersion();
                return this.fmV(v);
            }
        },
        enableShowFmAsync : function(callback){
            var that = this;
            this.getAppVersionAsync(function(ver){
                callback && callback(that.fmV(ver));
            });
        },
        /**
         *stitle 头部title判断版本
         */
        sTitle:function(id, onPin, unPin, fixFn, highFbn){
            if (!this.enableHideNav()){//低版本
                $(id).hide();
                fixFn && fixFn();
            }else{//高版本
                $(id).show();
                highFbn && highFbn();
                $('document').scroll(function(){
                    if ($('document').scrollTop() < 50){
                        onPin && onPin();
                    }else{
                        unPin && unPin();
                    }
                });
            }
        }


    };

    // version.init();  // 在这里执行的话，require引用它会报错，应该在引用它的地方调用，加快后续执行速度

    exports.version = version;    

    /**
     * 兼容AMD和非AMD规范
     */
    if (typeof define === "function" && define.amd) {
        define([ "jquery", "base" ], function($, base) {
            return version;
        });
    }
})(window);